
/**
 *  公共方法的提取,维护人秦恩啟、孙玉龙和常琳
 *
 */
var publicJs =  {
    init: function () {
        publicJs.methods.setLayer(); // 设置layer
        publicJs.methods.setServerName();   // 设置url
        publicJs.methods.setLayuiForm(); // 初始化form
        publicJs.methods.setLayDate(); // 初始化日期
        publicJs.methods.setTable(); // 赋值table
    },
    methods: {
        /*
          数据表格及是否分页
         id:table的id(必传)
         url:table数据的访问地址(必传)
         cols： 数据对象(必传)
         method: 请求方式(默认是get方式)
         paging: 是否分页（默认为true 不分页）
         limit： 每页多少条（默认是10条）
         even: 是否开启隔行变色(默认是false)
         size :默认是大尺寸lg,小尺寸sm
         data body对象
         fun 新增的回调函数
     */
        setPage : function (id, url, cols,  method, paging, limit, even, size, data,fun,fun2) {
            var method = method || "get";
            var paging = paging || false;
            var limit = limit || 10;
            var limits = [limit, 2*limit,3*limit];
            data = data || {};
            if (!even) {
                even = false ;
            }
            var size = size || "lg";
            layui.use('table', function(){
                var table = layui.table;
                table.render({
                    elem: '#' + id
                    ,url: url
                    ,method: method
                    ,cols: cols
                    ,page: paging //是否显示分页
                    ,limits: limits
                    ,limit: limit //每页默认显示的数量
                    ,even: even
                    ,size: size
                    ,where: data  // js对象
                    // ,width:300
                    // ,height:320
                    /* ,skin: 'line' //表格风格*/
                    ,loading: true
                    ,id : 'testReload'
                   /* ,contentType:"application/json; charset=utf-8"*/
                    ,request:{
                        pageName:'page',
                        limitName:'rows'
                    }
                    ,parseData: function(res){
                        console.log(res);
                        fun(res.result);
                        if (paging) {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "count": res.result.totalCount,
                                "data": res.result.list
                            };
                        }else {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "data": res.result.list
                            };
                        }
                    }
                    , done: function(res, curr, count){
                        if (fun2) {
                            fun2(res, table);
                        }
                    }
                });
            });
        },
        setPage02 : function (id, url, cols,  method, paging, limit, even, size, data,fun,fun2) {
            var method = method || "get";
            var paging = paging || false;
            var limit = limit || 10;
            var limits = [limit, 2*limit,3*limit];
            data = data || {};
            if (!even) {
                even = false ;
            }
            var size = size || "lg";
            layui.use('table', function(){
                var table = layui.table;
                table.render({
                    elem: '#' + id
                    ,url: url
                    ,method: method
                    ,cols: cols
                    ,page: paging //是否显示分页
                    ,limits: limits
                    ,limit: limit //每页默认显示的数量
                    ,even: even
                    ,size: size
                    ,where: data  // js对象
                    // ,width:300
                    // ,height:320
                    /* ,skin: 'line' //表格风格*/
                    ,loading: true
                    ,id : 'testReload'
                    ,contentType:"application/json; charset=utf-8"
                    ,request:{
                        pageName:'page',
                        limitName:'rows'
                    }
                    ,parseData: function(res){
                        // console.log(res);
                        fun(res.result);
                        if (paging) {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "count": res.result.totalCount,
                                "data": res.result.list
                            };
                        }else {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "data": res.result.list
                            };
                        }
                    }
                    , done: function(res, curr, count){
                        if (fun2) {
                            fun2(res, table);
                        }
                    }
                });
            });
        },
        setPage03 : function (id, url, cols,  method, paging, limit, even, size, data,fun,fun2) {
            var method = method || "get";
            var paging = paging || false;
            var limit = limit || 10;
            var limits = [limit, 2*limit,3*limit];
            data = data || {};
            if (!even) {
                even = false ;
            }
            var size = size || "lg";
            layui.use('table', function(){
                var table = layui.table;
                table.render({
                    elem: '#' + id
                    ,url: url
                    ,method: method
                    ,cols: cols
                    ,page: paging //是否显示分页
                    ,limits: limits
                    ,limit: limit //每页默认显示的数量
                    ,even: even
                    ,size: size
                    ,where: data  // js对象
                    // ,width:300
                    // ,height:320
                    /* ,skin: 'line' //表格风格*/
                    ,loading: true
                    ,id : 'testReload'
                    ,contentType:"application/json; charset=utf-8"
                    ,request:{
                        pageName:'page',
                        limitName:'rows'
                    }
                    ,parseData: function(res){
                        // console.log(res);
                        fun(res.result);
                        if (paging) {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "count": res.result.totalCount,
                                "data": res.result.datas
                            };
                        }else {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "data": res.result.datas
                            };
                        }
                    }
                    , done: function(res, curr, count){
                        if (fun2) {
                            fun2(res, table);
                        }
                    }
                });
            });
        },
        /*
        数据表格及是否分页
       id:table的id(必传)
       url:table数据的访问地址(必传)
       toolbar: 关联头部工具栏
       cols： 数据对象(必传)
       method: 请求方式(默认是get方式)
       paging: 是否分页（默认为true 不分页）
       limit： 每页多少条（默认是10条）
       even: 是否开启隔行变色(默认是false)
       size :默认是大尺寸lg,小尺寸sm
       data body对象
       fun 新增的回调函数
   */
        setPageXin : function (id, url, toolbar, cols,  method, paging, limit, even, size, data,fun,fun2) {
            var  toolbar = toolbar || "";
            var method = method || "get";
            var paging = paging || false;
            var limit = limit || 10;
            var limits = [limit, 2*limit,3*limit];
            data = data || {};
            if (!even) {
                even = false ;
            }
            var size = size || "lg";
            layui.use('table', function(){
                var table = layui.table;
                table.render({
                    elem: '#' + id
                    ,url: url
                    ,toolbar: '#' + toolbar
                    ,method: method
                    ,cols: cols
                    ,page: paging //是否显示分页
                    ,limits: limits
                    ,limit: limit //每页默认显示的数量
                    ,even: even
                    ,size: size
                    ,where: data  // js对象
                    // ,width:300
                    // ,height:320
                    /* ,skin: 'line' //表格风格*/
                    ,loading: true
                    ,id : 'testReload'
                    /* ,contentType:"application/json; charset=utf-8"*/
                    ,request:{
                        pageName:'page',
                        limitName:'rows'
                    }
                    ,parseData: function(res){
                        //console.log(res);
                        fun(res.result);
                        if (paging) {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "count": res.result.totalCount,
                                "data": res.result.list
                            };
                        }else {
                            return {
                                "code": res.code,
                                "msg": res.message,
                                "data": res.result.list
                            };
                        }
                    }
                    , done: function(res, curr, count){
                        if (fun2) {
                            fun2(res, table);
                        }
                    }
                });
            });
        },
        /**
         *  数据表格重载
         *  demoReload 是id值
         *
         * @param data    page （默认为false）分页
         *                 data  默认为false）为true 则从第一页开始重载
         *
         */
        reload: function (page, data) {
            var table = publicJs.methods.getTable();
            page = page || false;
            data = data || false;
            //执行重载
            if (page) {
                if (data) {
                    table.reload('roleTable', {
                        page: {
                            curr: 1 //重新从第 1 页开始
                        }
                    });
                }else {

                    table.reload('roleTable', {
                    });
                }
            }else {
                table.reload('roleTable', {
                });
            }
        },
        /**
         *  赋值table
         */
        setTable : function () {
            layui.use('table', function() {
                var table = layui.table;
                publicJs.data.dataTable = table;
            });
        },
        /**
         *  得到table
         */
        getTable: function () {
            return  publicJs.data.dataTable;
        },
        /**
         *  发送ajax请求
         *  _url 请求地址
         *  _type 请求类型 （默认是get方式）
         *  _data 请求对象数据
         *  _async 是否异步 （默认是false,同步）
         *  fun 回调函数
         *
         */
        ajaxRequest: function (_url, _type, _data, _async,fun) {
            _type = _type || "get";
            _async = _async || false;
            $.ajax({
                dataType:"json",
                url: _url,
                type: _type,
                data: _data,
                async: _async,
                timeout: 6000,    //超时时间
                traditional:true,
                contentType:"application/json; charset=utf-8",
                beforeSend:function () {   // 发送之前的验证

                },
                success: function (data) {
                    if (data.code === "000000") {  // 读取数据成功
                        fun(data.result);
                    }
                }, error: function () {
                    console.log('服务器真的异常，请稍后再试!');
                }
            });
        },
        ajaxRequestbd: function (_url, _type, _data, _async,fun) {
            _type = _type || "get";
            _async = _async || false;
            $.ajax({
                dataType:"json",
                url: _url,
                type: _type,
                data: _data,
                async: _async,
                timeout: 6000,    //超时时间
                traditional:true,
                contentType:"application/json; charset=utf-8",
                beforeSend:function () {   // 发送之前的验证

                },
                success: function (data) {
                    console.log(data)
                    if (data.code === "000000") {  // 读取数据成功
                        fun(data);
                    }else{
                        fun(data);
                    }
                }, error: function () {
                    console.log('服务器真的异常，请稍后再试!');
                }
            });
        },
        /**
         *   layer confirm 弹窗
         *
         * @param title  标题
         * @param content  内容
         * @param arr  按钮数组
         *  fun  回调函数
         */
        layerConfirm: function (title,content,arr,fun) {
            var layer = publicJs.methods.getLayer();
            //询问框
            layer.confirm(content, {
                title: title,
                btn: arr //按钮
            }, function(index){
                layer.close(index);
                fun();
            }, function(){

            });
        },

        /**  新打开的弹窗页面
         *  id: 子页面的id
         *  type 层类型（默认为2）
         * title 标题
         * area 宽高
         * maxmin 最大最小（默认为false）
         * content 地址(页面链接地址)
         * btn 按钮组
         */
        layerOpen: function (id, type, title, area, maxmin, content, btn, fun, fun2, fun3,fun4) {
            type = type || 2;
            title = title || "信息";
            area = area ||  ['390px', '260px'];
            maxmin = maxmin || false;
            // btn = btn || ['确定', '取消'];
            var layer = publicJs.methods.getLayer();
            layer.open({
                id: id
                ,type: type
                ,title: title
                ,area:area
                ,shade: 0.1
                ,shadeClose: true
                ,maxmin: maxmin
                ,content: content
                ,btn: btn
                ,yes: function(index,layero){   // 点击确认 回调
                    if (fun) {
                        fun( index,layero,layer);
                        layer.closeAll();
                    }
                }
                ,btn2: function(){
                    layer.closeAll();
                    if ( fun2) {
                        fun2($(this));
                    }
                }
                ,zIndex: layer.zIndex
                ,success: function(layero){
                    if (fun3) {
                        fun3("渲染成功");
                    }
                },end : function(data) {  // 关闭按钮
                    if (fun4) {
                        fun4();
                    }
                }
            });
        },

        /**
         *
         *  提示框
         *  mag 提示信息
         *  icon : -1(没有)  0：黄色感叹号  1：绿色对号  2：红色叉号  3：黄色问好  4：灰色小锁  5：红色笑脸  6：绿色笑脸
         *  closeBtn 1：有关闭按钮 ; 0：没有关闭按钮  默认为1
         *  fun: 确认按钮的回调函数
         */
        layerAlert: function (msg,icon, fun) {
            var layer = publicJs.methods.getLayer(); // 得到layer
            layer.alert(msg,
                {icon: 10
                    ,closeBtn:1    // 是否显示关闭按钮
                },
                function(index){
                    layer.close(index);
                    fun(index);
                });
        },


        /**
         *    下面是小插件的获取
         */
        /**
         *   设置layer
         */
       setLayer : function () {
           var layer = null;
           layui.use('layer', function(){
               layer = layui.layer;
               publicJs.data.getLayerData = layer; // data中放进一份数据
           });
       },
        /**
         *   得到layer
         */
        getLayer : function () {
            return  publicJs.data.getLayerData;
        },

        /**
         *  公共的访问地址 赋值
         */
        setServerName: function () {  // 给serverName  赋值
            publicJs.data.serverName = "http://192.168.0.110:8089/etax";
        },
        /**
         *  公共的访问地址 取值
         */
        getServerName: function () { // 得到serverName的值
            return  publicJs.data.serverName;
        },

        /**
         *  设置form对象
         */
        setLayuiForm: function () {   // 初始化form
            layui.use('form', function(){
                publicJs.data.layuiForm = layui.form;//高版本建议把括号去掉，有的低版本，需要加()
            });
        },
        /**
         *  取form对象
         */
        getLayuiForm: function () {  // 得到form
            return publicJs.data.layuiForm;
        },

        /**
         *   设置日期插件
         */
        setLayDate: function () {
            layui.use('laydate', function() {
                var laydate = layui.laydate;
                publicJs.data.laydate = laydate;
            })
        },
        /**
         *   得到日期插件
         */
        getLayDate: function () {
            return publicJs.data.laydate;
        },

        /**
         *  日期插件的初始化
         *  id: 指定元素id (必传)
         *  type: 控件选择类型,默认date
         *  format: 日期格式,默认yyyy-MM-dd
         *  value   初始值 默认为""
         *  showBottom 显示底部栏(默认值为false)
         *   fun1(date)  控件初始打开的回调
         *  fun2(value, date, endDate)
         *
         */
        layDateRender: function ( id, type, format, value, showBottom, fun1, fun2) {
            type = type || "date";
            format = format || "yyyy-MM-dd";
            value = value || "";
            if (!showBottom) {
                showBottom = showBottom || false;
            }
            layui.use('laydate', function() {
                layDate = layui.laydate;
                layDate.render({
                    elem: '#' + id              //指定元素
                    ,type: type                 //默认date，可不填
                    ,format: format      // 默认yyyy-MM-dd
                    ,value: value      //必须遵循format参数设定的格式  默认为""
                    ,isInitValue: true          //是否允许填充初始值，默认为 false
                    ,show: false                //直接显示
                    ,showBottom: showBottom           // 显示底部栏
                    ,btns: ['clear', 'now']
                    ,ready: function(date){     // 控件初始打开的回调
                        if (fun1){
                            fun1(date);
                        }
                    }
                    ,done: function(value, date, endDate){  // 控件选择完毕后的回调
                        if (fun2) {
                            fun2(value, date, endDate);
                        }
                    }
                });
            })
        },

    },
    data: {
        layuiForm: null,
        laydate: null,
        serverName: null,
        tableData: "",
        dataTable: ""
    }
}
publicJs.init();

